home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / DocXMLRPCServer.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  10KB  |  264 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Self documenting XML-RPC Server.
  5.  
  6. This module can be used to create XML-RPC servers that
  7. serve pydoc-style documentation in response to HTTP
  8. GET requests. This documentation is dynamically generated
  9. based on the functions and methods registered with the
  10. server.
  11.  
  12. This module is built upon the pydoc and SimpleXMLRPCServer
  13. modules.
  14. '''
  15. import pydoc
  16. import inspect
  17. import types
  18. import re
  19. import sys
  20. from SimpleXMLRPCServer import SimpleXMLRPCServer, SimpleXMLRPCRequestHandler, CGIXMLRPCRequestHandler, resolve_dotted_attribute
  21.  
  22. class ServerHTMLDoc(pydoc.HTMLDoc):
  23.     '''Class used to generate pydoc HTML document for a server'''
  24.     
  25.     def markup(self, text, escape = None, funcs = { }, classes = { }, methods = { }):
  26.         '''Mark up some plain text, given a context of symbols to look for.
  27.         Each context dictionary maps object names to anchor names.'''
  28.         if not escape:
  29.             pass
  30.         escape = self.escape
  31.         results = []
  32.         here = 0
  33.         pattern = re.compile('\\b((http|ftp)://\\S+[\\w/]|RFC[- ]?(\\d+)|PEP[- ]?(\\d+)|(self\\.)?((?:\\w|\\.)+))\\b')
  34.         while None:
  35.             match = pattern.search(text, here)
  36.             if not match:
  37.                 break
  38.             
  39.             (start, end) = match.span()
  40.             (all, scheme, rfc, pep, selfdot, name) = match.groups()
  41.             if scheme:
  42.                 url = escape(all).replace('"', '"')
  43.                 results.append('<a href="%s">%s</a>' % (url, url))
  44.             elif rfc:
  45.                 url = 'http://www.rfc-editor.org/rfc/rfc%d.txt' % int(rfc)
  46.                 results.append('<a href="%s">%s</a>' % (url, escape(all)))
  47.             elif pep:
  48.                 url = 'http://www.python.org/peps/pep-%04d.html' % int(pep)
  49.                 results.append('<a href="%s">%s</a>' % (url, escape(all)))
  50.             elif text[end:end + 1] == '(':
  51.                 results.append(self.namelink(name, methods, funcs, classes))
  52.             elif selfdot:
  53.                 results.append('self.<strong>%s</strong>' % name)
  54.             else:
  55.                 results.append(self.namelink(name, classes))
  56.             here = end
  57.         results.append(escape(text[here:]))
  58.         return ''.join(results)
  59.  
  60.     
  61.     def docroutine(self, object, name = None, mod = None, funcs = { }, classes = { }, methods = { }, cl = None):
  62.         '''Produce HTML documentation for a function or method object.'''
  63.         if not cl or cl.__name__:
  64.             pass
  65.         anchor = '' + '-' + name
  66.         note = ''
  67.         title = '<a name="%s"><strong>%s</strong></a>' % (anchor, name)
  68.         if inspect.ismethod(object):
  69.             (args, varargs, varkw, defaults) = inspect.getargspec(object.im_func)
  70.             argspec = inspect.formatargspec(args[1:], varargs, varkw, defaults, formatvalue = self.formatvalue)
  71.         elif inspect.isfunction(object):
  72.             (args, varargs, varkw, defaults) = inspect.getargspec(object)
  73.             argspec = inspect.formatargspec(args, varargs, varkw, defaults, formatvalue = self.formatvalue)
  74.         else:
  75.             argspec = '(...)'
  76.         if isinstance(object, types.TupleType):
  77.             if not object[0]:
  78.                 pass
  79.             argspec = argspec
  80.             if not object[1]:
  81.                 pass
  82.             docstring = ''
  83.         else:
  84.             docstring = pydoc.getdoc(object)
  85.         if note:
  86.             pass
  87.         decl = title + argspec + self.grey('<font face="helvetica, arial">%s</font>' % note)
  88.         doc = self.markup(docstring, self.preformat, funcs, classes, methods)
  89.         if doc:
  90.             pass
  91.         doc = '<dd><tt>%s</tt></dd>' % doc
  92.         return '<dl><dt>%s</dt>%s</dl>\n' % (decl, doc)
  93.  
  94.     
  95.     def docserver(self, server_name, package_documentation, methods):
  96.         '''Produce HTML documentation for an XML-RPC server.'''
  97.         fdict = { }
  98.         for key, value in methods.items():
  99.             fdict[key] = '#-' + key
  100.             fdict[value] = fdict[key]
  101.         
  102.         head = '<big><big><strong>%s</strong></big></big>' % server_name
  103.         result = self.heading(head, '#ffffff', '#7799ee')
  104.         doc = self.markup(package_documentation, self.preformat, fdict)
  105.         if doc:
  106.             pass
  107.         doc = '<tt>%s</tt>' % doc
  108.         result = result + '<p>%s</p>\n' % doc
  109.         contents = []
  110.         method_items = methods.items()
  111.         method_items.sort()
  112.         for key, value in method_items:
  113.             contents.append(self.docroutine(value, key, funcs = fdict))
  114.         
  115.         result = result + self.bigsection('Methods', '#ffffff', '#eeaa77', pydoc.join(contents))
  116.         return result
  117.  
  118.  
  119.  
  120. class XMLRPCDocGenerator:
  121.     '''Generates documentation for an XML-RPC server.
  122.  
  123.     This class is designed as mix-in and should not
  124.     be constructed directly.
  125.     '''
  126.     
  127.     def __init__(self):
  128.         self.server_name = 'XML-RPC Server Documentation'
  129.         self.server_documentation = 'This server exports the following methods through the XML-RPC protocol.'
  130.         self.server_title = 'XML-RPC Server Documentation'
  131.  
  132.     
  133.     def set_server_title(self, server_title):
  134.         '''Set the HTML title of the generated server documentation'''
  135.         self.server_title = server_title
  136.  
  137.     
  138.     def set_server_name(self, server_name):
  139.         '''Set the name of the generated HTML server documentation'''
  140.         self.server_name = server_name
  141.  
  142.     
  143.     def set_server_documentation(self, server_documentation):
  144.         '''Set the documentation string for the entire server.'''
  145.         self.server_documentation = server_documentation
  146.  
  147.     
  148.     def generate_html_documentation(self):
  149.         '''generate_html_documentation() => html documentation for the server
  150.  
  151.         Generates HTML documentation for the server using introspection for
  152.         installed functions and instances that do not implement the
  153.         _dispatch method. Alternatively, instances can choose to implement
  154.         the _get_method_argstring(method_name) method to provide the
  155.         argument string used in the documentation and the
  156.         _methodHelp(method_name) method to provide the help text used
  157.         in the documentation.'''
  158.         methods = { }
  159.         for method_name in self.system_listMethods():
  160.             if self.funcs.has_key(method_name):
  161.                 method = self.funcs[method_name]
  162.             elif self.instance is not None:
  163.                 method_info = [
  164.                     None,
  165.                     None]
  166.                 if hasattr(self.instance, '_get_method_argstring'):
  167.                     method_info[0] = self.instance._get_method_argstring(method_name)
  168.                 
  169.                 if hasattr(self.instance, '_methodHelp'):
  170.                     method_info[1] = self.instance._methodHelp(method_name)
  171.                 
  172.                 method_info = tuple(method_info)
  173.                 None if method_info != (None, None) else None<EXCEPTION MATCH>AttributeError
  174.                 method = method_info
  175.             elif not 0:
  176.                 raise AssertionError, 'Could not find method in self.functions and no instance installed'
  177.             methods[method_name] = method
  178.         
  179.         documenter = ServerHTMLDoc()
  180.         documentation = documenter.docserver(self.server_name, self.server_documentation, methods)
  181.         return documenter.page(self.server_title, documentation)
  182.  
  183.  
  184.  
  185. class DocXMLRPCRequestHandler(SimpleXMLRPCRequestHandler):
  186.     '''XML-RPC and documentation request handler class.
  187.  
  188.     Handles all HTTP POST requests and attempts to decode them as
  189.     XML-RPC requests.
  190.  
  191.     Handles all HTTP GET requests and interprets them as requests
  192.     for documentation.
  193.     '''
  194.     
  195.     def do_GET(self):
  196.         '''Handles the HTTP GET request.
  197.  
  198.         Interpret all HTTP GET requests as requests for server
  199.         documentation.
  200.         '''
  201.         response = self.server.generate_html_documentation()
  202.         self.send_response(200)
  203.         self.send_header('Content-type', 'text/html')
  204.         self.send_header('Content-length', str(len(response)))
  205.         self.end_headers()
  206.         self.wfile.write(response)
  207.         self.wfile.flush()
  208.         self.connection.shutdown(1)
  209.  
  210.  
  211.  
  212. class DocXMLRPCServer(SimpleXMLRPCServer, XMLRPCDocGenerator):
  213.     '''XML-RPC and HTML documentation server.
  214.  
  215.     Adds the ability to serve server documentation to the capabilities
  216.     of SimpleXMLRPCServer.
  217.     '''
  218.     
  219.     def __init__(self, addr, requestHandler = DocXMLRPCRequestHandler, logRequests = 1):
  220.         SimpleXMLRPCServer.__init__(self, addr, requestHandler, logRequests)
  221.         XMLRPCDocGenerator.__init__(self)
  222.  
  223.  
  224.  
  225. class DocCGIXMLRPCRequestHandler(CGIXMLRPCRequestHandler, XMLRPCDocGenerator):
  226.     '''Handler for XML-RPC data and documentation requests passed through
  227.     CGI'''
  228.     
  229.     def handle_get(self):
  230.         '''Handles the HTTP GET request.
  231.  
  232.         Interpret all HTTP GET requests as requests for server
  233.         documentation.
  234.         '''
  235.         response = self.generate_html_documentation()
  236.         print 'Content-Type: text/html'
  237.         print 'Content-Length: %d' % len(response)
  238.         print 
  239.         sys.stdout.write(response)
  240.  
  241.     
  242.     def __init__(self):
  243.         CGIXMLRPCRequestHandler.__init__(self)
  244.         XMLRPCDocGenerator.__init__(self)
  245.  
  246.  
  247. if __name__ == '__main__':
  248.     
  249.     def deg_to_rad(deg):
  250.         '''deg_to_rad(90) => 1.5707963267948966
  251.  
  252.         Converts an angle in degrees to an angle in radians'''
  253.         import math as math
  254.         return deg * math.pi / 180
  255.  
  256.     server = DocXMLRPCServer(('localhost', 8000))
  257.     server.set_server_title('Math Server')
  258.     server.set_server_name('Math XML-RPC Server')
  259.     server.set_server_documentation('This server supports various mathematical functions.\n\nYou can use it from Python as follows:\n\n>>> from xmlrpclib import ServerProxy\n>>> s = ServerProxy("http://localhost:8000")\n>>> s.deg_to_rad(90.0)\n1.5707963267948966')
  260.     server.register_function(deg_to_rad)
  261.     server.register_introspection_functions()
  262.     server.serve_forever()
  263.  
  264.